package  
{
	/**
	 * ...
	 * @author Team Izanami
	 */
	
	import flash.events.KeyboardEvent;
	import flash.events.Event;
	 
	public class Camera extends Carte
	{
		private var _enSaut:Boolean = false;
		private var _vitesseSautLimite:int = 15;
		private var _vitesseSaut:int = _vitesseSautLimite;
		private var toucheGauche:Boolean = false;
		private var toucheDroite:Boolean = false;
		private var toucheSaut:Boolean = false;
		private var toucheGrip:Boolean = false;
		private var aFlip:Boolean = false; // Indique si l'on a déjà fait flipper l'annim
		private var numeroplateforme:int = 0; // numéro de la dernière plateforme sur laquelle le joueur s'est trouvé.
		private var numerogrip:int = 0; // numéro du grip sur lequel le joueur doit aller
		private var surGrip:int  = 0; // 0 = n'est pas sur un grip, 1 = Doit aller sur le grip, 2 = est sur le grip 
		
		
		
		//***************
		// ACCESSORS
		//***************

		
		
		
		
		
		
		
		//***************
		// METHODS
		//***************
		
		public function Camera(heros_temp:Heros,Cnom_Carte:String) 
		{
			Izanami = heros_temp;
			super(Cnom_Carte);
			addEventListener(Event.ADDED_TO_STAGE, initialisation);
		}
		
		////////////////////////////////////////////////
		/// FONCTIONS UTILISEES POUR LE DEPLACEMENT  ///
		////////////////////////////////////////////////
		
		public function deplacement(direction:String):void // Simule une caméra en cas de déplacement du personnage sur le côté
		{
			if (direction == "droite")
			{
				for (var i:int = 0; i < mur.length; i ++)
				{
					
					
				}
				if ((carte_premier_plan.x > (800 - longeur_max )))
				{
					if (Izanami.returnX() > 500) 
					{						
						carte_premier_plan.x -= Izanami.returnVitesse();
						Izanami.changeXNonRelative(Izanami.returnXNonRelative() + Izanami.returnVitesse());
					}
					else 
					{
						Izanami.modifX (Izanami.returnX() + Izanami.returnVitesse());
						Izanami.changeXNonRelative(Izanami.returnXNonRelative() + Izanami.returnVitesse());
					}
				}
				
				
					
					else if (Izanami.returnXNonRelative() < longeur_max)
					{
						Izanami.modifX (Izanami.returnX() + Izanami.returnVitesse());
						Izanami.changeXNonRelative(Izanami.returnXNonRelative() + Izanami.returnVitesse());
					}
			}			
				

			
			else if (direction == "gauche" && Izanami.returnX() >= 0)
			{
				if (carte_premier_plan.x >= 0) // Si l'on est au début de la carte, le héros se déplace
				{
					Izanami.modifX(Izanami.returnX() - Izanami.returnVitesse());
					Izanami.changeXNonRelative(Izanami.returnXNonRelative() - Izanami.returnVitesse());
				}
				else if (Izanami.returnX() < 300)   
				{
					carte_premier_plan.x += Izanami.returnVitesse();
					Izanami.changeXNonRelative(Izanami.returnXNonRelative() - Izanami.returnVitesse());
				}
				else  
				{
					Izanami.modifX(Izanami.returnX() - Izanami.returnVitesse());
					Izanami.changeXNonRelative(Izanami.returnXNonRelative() - Izanami.returnVitesse());
				}
			}
			
		
			

				if (!(Izanami.estEnCollision(plateforme[numeroplateforme].getposX(),plateforme[numeroplateforme].getposXmax(), plateforme[numeroplateforme].getposY())) && _enSaut == false) // on vérifie que l'on est sur aucune plateforme
					{
						_enSaut = true;
						_vitesseSaut = 2;
					}	
						
			
			
		}
		
		public function saut ():void 
		{
			if (!_enSaut)
			{
				_enSaut = true;
				_vitesseSaut = _vitesseSautLimite * -1;
				Izanami.changeY(_vitesseSaut + Izanami.returnY());
			}
			
			else 
			{
				if (_vitesseSaut < 0)
				{
					_vitesseSaut *= 1 - _vitesseSautLimite / 130;
					if (_vitesseSaut > -_vitesseSautLimite / 5)
					{
						_vitesseSaut *= -1;
					}
				}
				if (_vitesseSaut > 0 && _vitesseSaut <= _vitesseSautLimite)
				{
					_vitesseSaut *= 1 + _vitesseSautLimite / 50;
				}
				
				
				var surPlateforme:Boolean = false;
				if (_vitesseSaut > 0)
					{
						for (var i:int = 0; i < plateforme.length; i ++)
							{
							if (Izanami.estEnCollision(plateforme[i].getposX(),plateforme[i].getposXmax(), plateforme[i].getposY()))// on vérifie la position en X de toute les plateformes
								{      
									surPlateforme = true;
									_enSaut = false;
									Izanami.changeY(plateforme[i].getposY());
									numeroplateforme = i;
								}
						
							}
					}
				else
					{
						Izanami.changeY(_vitesseSaut + Izanami.returnY());
					}
				
				if (!surPlateforme)
					{
							Izanami.changeY(_vitesseSaut + Izanami.returnY());
					}
				
				
			}
			
		}
			
		public function initialisation(m:Event):void //Début d'initialisation
		{
			removeEventListener(Event.ADDED_TO_STAGE, initialisation);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, deplacementBool);
			stage.addEventListener(KeyboardEvent.KEY_UP, annudeplacement);
			Izanami.addEventListener(Event.ENTER_FRAME, deplacementIzanami);
		}
		
		public function deplacementIzanami(m:Event):void 
		{
			if (! (surGrip != 0))
			{
				
			
				if (toucheGrip)
				{
					this.procheGrip();
				}
				if (toucheGauche) 
				{
					this.deplacement("gauche");
					if (!aFlip)
					{
						aFlip = true;
						Izanami.setAnim("marche", true);
					}
					else
					{
						Izanami.setAnim("marche", false);
					}
					
				}
				else if (toucheDroite) 
				{
					this.deplacement("droite");
					if (aFlip)
					{
						aFlip = false;
						Izanami.setAnim("marche", true);
					}
					else
					{
						Izanami.setAnim("marche", false);
					}
				
				}
				else 
				{
					Izanami.setAnim("idle", false);
				}
				if (toucheSaut) 
				{
					this.saut();
				}
			
				if (!_enSaut)
				{
					toucheSaut = false;
				}
				if (_enSaut)
				{
					toucheSaut = true;
				}
			}
		
			else
			{
				deplacementGrip();
			}
		}
		
		public function deplacementBool (m:KeyboardEvent):void
		{
			if (m.keyCode == 68)
			toucheDroite = true;
			if (m.keyCode == 81)
			toucheGauche = true;
			if (m.keyCode == 32) 
			toucheSaut = true;	
			if (m.keyCode == 69)
			toucheGrip = true;
		}
		
		public function annudeplacement (m:KeyboardEvent):void
		{
			if (m.keyCode == 68)
			toucheDroite = false;
			if (m.keyCode == 81)
			toucheGauche = false;
			if (m.keyCode == 32 && !_enSaut)
			toucheSaut = false;
			if (m.keyCode == 69)
			toucheGrip = false;
		}
		
		
		///////////////////////////////////////////
		/// FONCTIONS UTILISEES POUR LES GRIPS ///
		//////////////////////////////////////////
		
		public function procheGrip():void
		{
			for (var i:int = 0; i < grip.length; i ++)
			{
				if (Izanami.bonneDistanceGrip(grip[i].returnPosX(), grip[i].returnPosY()))
				{
					numerogrip = i;
					surGrip = 1;
				}
			}
			
		}

		public function deplacementGrip():void
		{
			Izanami.modifVitesse(5); // On augmente temporairement la vitesse du héros
			if (surGrip == 1) // si le joueur doit atteindre le grip
			{
				if (Izanami.returnXNonRelative() > grip[numerogrip].returnPosX())
				{
					if (Izanami.returnXNonRelative() - 5 <= grip[numerogrip].returnPosX())
					{
						Izanami.changeXNonRelative(grip[numerogrip].returnPosX());
						Izanami.modifX(grip[numerogrip].returnPosX() - (Izanami.returnXNonRelative() - Izanami.returnX()));
					}
					else 
					{
						this.deplacement("gauche");
					}
				}
				else if ((Izanami.returnXNonRelative() < grip[numerogrip].returnPosX()))
				{
					if (Izanami.returnXNonRelative() + 5 >= grip[numerogrip].returnPosX())
					{
						Izanami.changeXNonRelative(grip[numerogrip].returnPosX());
						Izanami.modifX(grip[numerogrip].returnPosX() - (Izanami.returnXNonRelative() - Izanami.returnX()));
					}
					else 
					{
						this.deplacement("droite");
					}
				}
				
				if ((Izanami.returnY() > grip[numerogrip].returnPosY()))
				{
					if (Izanami.returnY() - 5 <= grip[numerogrip].returnPosY())
					{
						Izanami.changeY(grip[numerogrip].returnPosY());
					}
					else 
					{
						Izanami.changeY(Izanami.returnY() - 5);
					}
				}
				else if ((Izanami.returnY() < grip[numerogrip].returnPosY()))
				{
					if  (Izanami.returnY() + 5 <= grip[numerogrip].returnPosY())
					{
						Izanami.changeY(grip[numerogrip].returnPosY());
					}
					else
					{
						Izanami.changeY(Izanami.returnY() + 5);
					}
				}
				
				
				if (Izanami.returnXNonRelative() == grip[numerogrip].returnPosX() && Izanami.returnY() == grip[numerogrip].returnPosY())
				{
					surGrip = 2; // L'on a atteint le grip, on passe à l'étape suivant
				}
			}
			
			if (surGrip == 2) // si le joueur suit le grip
			{
				if (Izanami.returnXNonRelative() < grip[numerogrip].returnPosXMaximal()) // Tant que l'on a pas quitté le grip
				{
					this.deplacement(grip[numerogrip].returnDirection());
					Izanami.changeY(grip[numerogrip].determineY(Izanami.returnXNonRelative()))
				}
				else
				{
					surGrip = 0;
					_enSaut = true;
					_vitesseSaut = 2;
					Izanami.resetVitesse();
				}
			}
		}
	}
}
